
// {*****PENAMBAHAN ELEMEN - SPECIAL*****}
void InsertVTerurut (ListMember * L, infotype X)
// { I.S. L mungkin kosong, L adalah list terurut }
// { F.S. X ditambahkan sebagai elemen L dengan menjaga keterurutan L }
// { Proses : Melakukan alokasi sebuah elemen dan mencari tempat yang tepat untuk diinsert }
// { MEnggunakan fungsi IsLess dan IsMore pada ADT_Infotype}
// Jika alokasi gagal: I.S.= F.S. }
{
	address1 P, PP, Prec;
	
	Alokasi(&P,X);
	if (P != Nil)
	{
		if (IsListEmpty(*L))
		{
			First(*L) = P;
		}
		else
		{
			Prec = Nil;
			PP = First(*L);
			while ((Next(PP) != Nil) & (!IsLess))
			{
				Prec = PP;
				PP = Next(PP);
			}
			
			if (IsLess)
			{
				if (Prec == Nil)
				{
					Next(P) = First(*L);
					First(*L) = P;
				}
				else
				{
					Next(P) = Next(Prec);
					Next(Prec) = P;
				}
			}
			else
			{
				Next(PP) = P;
			}
		}
	}
}

void InsertTerurut (ListMember * L, address P)
// { I.S. L mungkin kosong, L adalah list terurut, P sudah dialokasi }
// { F.S. Menambahkan elemen ber-address P sebagai elemen L dengan menjaga keterurutan list }
{
	address1 PP, Prec;
	
	if (IsListEmpty(*L))
	{
		First(*L) = P;
	}
	else
	{
		Prec = Nil;
		PP = First(*L);
		while ((Next(PP) != Nil) & (!IsLess))
		{
			Prec = PP;
			PP = Next(PP);
		}
		
		if (IsLess)
		{
			if (Prec == Nil)
			{
				Next(P) = First(*L);
				First(*L) = P;
			}
			else
			{
				Next(P) = Next(Prec);
				Next(Prec) = P;
			}
		}
		else
		{
			Next(PP) = P;
		}
	}
}

// {***************PEMPROSESAN ELEMEN LIST OF LIST (FRIEND) ***************}
// {*****MEMORY_MANAGEMENT*****}

address2 AlokasiFriend(address1 X);
// { Mengirimkan address hasil alokasi sebuah elemen }
// { Jika alokasi berhasil, maka address tidak Nil, dan misalnya menghasilkan P, maka
// Info(P) = X, Next(P) = Nil }
// { Jika alokasi gagal, mengirimkan Nil }
{
	address2 tmp;
	
	tmp = (address2) malloc (1 * sizeof(FriendSosNet));
	
	if (tmp != Nil)
	{
		Info(tmp) = X;
		Next(tmp) = Nil;
	}
	else
	{
		tmp = Nil;
	}
	return tmp;
}
		
void DealokasiFriend(address2 *P);
// { I.S. P terdefinisi }
// { F.S. P dikembalikan ke sistem }
// { Melakukan dealokasi/pengembalian address P }
{
	free(*P);
}

// {*****TRAVERSAL LIST OF LIST*****}
int NBFriend(address1 LL);
// {Mengembalikan jumlah friend dari elemen dengan address P}
{
	address2 P;
	int count;
	
	P=TemanMember(LL);
	count = 0;
	
	while(P != Nil)
	{
		count++;
		P = Next(P);
	}
	
	return count;
}

bool IsFriend(address1 LL, address1 X);
// {Mengembalikan true jika X adalah friend dari LL}
{
	address2 P;
	bool bol;
	
	P=TemanMember(LL);
	bol = false
	while ((P != Nil) & (!bol))
	{
		if (X = Info(P))
		{
			bol = true;
		}
		else
		{
			P = Next(P);
		}
	}
	return bol;
}

// {*****PENAMBAHAN FRIEND*****}
void InsertVFriend(address1 LL, address1 X);
// { I.S. Sembarang }
// { F.S. X ditambahkan sebagai elemen terakhir yang baru }
// Jika alokasi gagal: I.S.= F.S.
{
	address2 P, tmp;
	
	tmp = AlokasiFriend(X);
	if (tmp != Nil)
	{
		if(TemanMember(LL) == Nil)
		{
			TemanMember(LL) = tmp;
		}
		else
		{
			P=TemanMember(LL);
			while (Next(P) != Nil)
			{
				P = Next(P);
			}
			Next(P) = tmp;
		}
	}
}
	

void InsertFriend(address1 LL, address2 P);
// { I.S. Sembarang, P sudah dialokasi }
// { F.S. P ditambahkan sebagai elemen terakhir yang baru }
{
	address2 PP;
	
	if(TemanMember(LL) == Nil)
	{
		TemanMember(LL) = P;
	}
	else
	{
		PP=TemanMember(LL);
		while (Next(PP) != Nil)
		{
			PP = Next(PP);
		}
		Next(PP) = P;
	}
}
	
void DelVFriend(address1 LL, address1 X);
// { I.S. Sembarang }
// { F.S. X terhapus dari LL, apabila X adalah friend dari SS 
// Jika X bukan merupakan friend dari SS maka I.S = F.S }
{
	address2 P,Prec;
	
	P=TemanMember(LL);
	Prec = Nil;
	
	if (IsFriend(LL,X))
	{
		while (Info(P) != X) 
		{
			Prec = P;
			P = Next(P);
		}
		
		if(Prec != Nil)
		{
			Next(Prec) = Next(P);
			DealokasiFriend(&P);
		}
		else
		{
			TemanMember(LL) = Next(P);
			DealokasiFriend(&P);
		}
	}
}

void DeleteFriend(address1 LL, address2 P);
// {Prekondisi: address P pasti merupakan bagian dari list friend LL}
{
	address2 PP,Prec;
	
	PP = TemanMember(LL);
	Prec = Nil;
	
	while (PP != P)
	{
		Prec = PP;
		PP = Next(PP);
	}
	
	if(Prec != Nil)
	{
		Next(Prec) = Next(PP);
		DealokasiFriend(&PP);
	}
	else
	{
		TemanMember(LL) = Next(&PP);
		DealokasiFriend(&PP);
	}
}